import java.awt.BasicStroke;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.Stroke;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseWheelListener;
import java.awt.geom.Line2D;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.ArrayList;
import javax.swing.BorderFactory;
import javax.swing.JApplet;
import javax.swing.JButton;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.Timer;

public class FyysikaVektor extends JApplet {

	private static final long serialVersionUID = 1L;
	Vektorid mycanvas = new  Vektorid();
	
	public class Vektorid extends JPanel implements ActionListener {
		private static final long serialVersionUID = 1L;
		JMenuBar menubar;
		JMenu esimene_Menu, teine_Menu, kolmas_Menu;
		JMenuItem item;
		ArrayList<JMenuItem> kustutaMenuItem = new ArrayList<JMenuItem>();
		JScrollPane scrollPane;
		JPanel ylemine;
		KeskPaneel keskmine;
		JButton zuum_sisse_nupp, zuum_valja_nupp, eelmine_samm, jargmine_samm, vaata_lahendust, vaata_anim, suurenda, v2henda;
		VektorKogum vektorikogu, liituvate_vektorite_kogu, vektorikogu_suunad_lahutamiseks;
		Vektor uus_vektor;
		Vektor vektorite_liitmise_tulemus;
		Timer taimer, liidetud_vektori_timer;
		Boolean naita_vektorite_liitmist= false, naita_lypp_liidetavat = false, pane_liidetud_tulemus_vilkuma=true;
		Ylesannete_kogu fyysika_ylesanded;
		int display_mode = 0, time=0, zoomSize = 50, parajasti_liidetav_vektor=1, time_liidetav_vektor=1, aeg = 6, time_temp=1, tehte_liik = 1;
		double k, r = 200;

		public Vektorid() {
			setLayout(new BorderLayout(3, 3));
			ylemine = new JPanel();
			ylemine.setLayout(new FlowLayout(FlowLayout.LEFT));
			ylemine.setBorder(BorderFactory.createEtchedBorder());
			vektorikogu = new VektorKogum();
			ylemine.add(getMenuBar());
			add(ylemine, BorderLayout.NORTH);
			fyysika_ylesanded = new Ylesannete_kogu(2);
			yl_nupud_nahtamatuks();
			keskmine = new KeskPaneel();
			keskmine.setLayout(new BorderLayout());
			scrollPane = new JScrollPane(keskmine);
			add(scrollPane, BorderLayout.CENTER);
			// add(keskmine, BorderLayout.CENTER);
			taimer = new Timer(30, new ActionListener() {
				public void actionPerformed(ActionEvent arg0) {
					
					 time_temp += aeg;
					 if (time_temp > 6) {
						 time += 1;
						 time_temp=0;
						 // if (time > 100) taimer.stop();
						 repaint();
					 }
					
				}
			});
			liidetud_vektori_timer = new Timer(300, new ActionListener() {
				public void actionPerformed(ActionEvent arg0) {
					 time_liidetav_vektor += 1;
					if (time_liidetav_vektor > 9) liidetud_vektori_timer.stop();
					if (naita_lypp_liidetavat) {
						naita_lypp_liidetavat = false;
					} else {
						naita_lypp_liidetavat = true;
					}
					repaint();
				}
			});
		}

		private void yl_nupud_nahtavaks() {
			eelmine_samm.setVisible(true);
			jargmine_samm.setVisible(true);
			vaata_lahendust.setVisible(true);
			vaata_anim.setVisible(true);
			kontrolli_ylesannete_nuppude_staatust();
		}

		private void yl_nupud_nahtamatuks() {
			eelmine_samm.setVisible(false);
			jargmine_samm.setVisible(false);
			vaata_lahendust.setVisible(false);
			vaata_anim.setVisible(false);
		}

		private class Animatsiooni_statsid {
			int x1, y1, x2, y2, noolepikkus = 15, w, h ;
			int X_koord, Y_koord, X_nihe, Y_nihe, X_last, Y_last;
			boolean joonistame_uut_vektorit = false, naitakoord = false;
			Animatsiooni_statsid(){
				
				
			}
			
		}
		
		private class KeskPaneel extends JPanel implements MouseListener, MouseMotionListener, MouseWheelListener {
			private static final long serialVersionUID = 1L;
			NumberFormat nf = new DecimalFormat("#00.0");
			ArrayList <Animatsiooni_statsid> animatsioonide_kogum = new ArrayList <Animatsiooni_statsid>();
			
			KeskPaneel() {
				this.setPreferredSize(new Dimension(800,500));
				// setBackground(Color.WHITE);
				this.addMouseListener(this);
				this.addMouseMotionListener(this);
				this.addMouseWheelListener(this);
				Animatsiooni_statsid main_stats = new Animatsiooni_statsid();
				animatsioonide_kogum.add(main_stats);
				this.add(new KanvasPaneel());
			}
			
			private class KanvasPaneel extends JPanel {
				private static final long serialVersionUID = 1L;

				KanvasPaneel() {
					
				}
				
				public void paintComponent(Graphics g) {
					super.paintComponent(g);
					
					g.setColor(Color.red);
					g.drawOval(99, 99, 400, 400);
					
				}
			}

			public void paintComponent(Graphics g) {
				super.paintComponent(g);
				switch (display_mode) {
					case 0:
						display_vektorid (g, getWidth()/2, getHeight()/2,  getWidth()/4, getHeight()/4,true, vektorikogu, animatsioonide_kogum.get(0));
						break;
					case 1:
						display_ylesanne (g);
						break;
					case 2: 
						display_vektorid (g, getWidth()/2, getHeight()/2, getWidth()/4, getHeight()/4, false, vektorikogu, animatsioonide_kogum.get(0));
						break;
					default: 
						System.out.println("Undefined display mode");
				}
			}

			private void display_vektorid(Graphics g, int laius, int korgus, int algus_punkt_x, int algus_punkt_y, boolean koord, VektorKogum vektorid, Animatsiooni_statsid stats) {
				zuum_valja_nupp.setVisible(false);
				zuum_sisse_nupp.setVisible(false);
				suurenda.setVisible(true);
				v2henda.setVisible(true);
				stats.w = laius;
				stats.h = korgus;
				int x = stats.w/2 + stats.X_nihe + algus_punkt_x;
				int y = stats.h/2 + stats.Y_nihe + algus_punkt_y;
				Graphics2D g2 = (Graphics2D) g;
				
				if(koord) {
					g2.setColor(Color.RED);
					g2.drawLine(algus_punkt_x, algus_punkt_y + 1, algus_punkt_x + stats.w, algus_punkt_y + 1);  // ylemine a:a:rejoon
					g2.setColor(Color.BLUE);
					g2.drawLine(algus_punkt_x+1, algus_punkt_y, algus_punkt_x+1, algus_punkt_y + stats.h);  // vasak a:a:rejoon
					g2.setColor(Color.GREEN);
					g2.drawLine(algus_punkt_x + stats.w - 1, algus_punkt_y, algus_punkt_x + stats.w - 1, algus_punkt_y + stats.h-1); // parem a:a:rejoon 
					g2.setColor(Color.CYAN);
					g2.drawLine(algus_punkt_x, algus_punkt_y + stats.h-1, algus_punkt_x + stats.w, algus_punkt_y + stats.h-1); // alumine a:a:rejoon
					int vektori_nr = 0;
					BasicStroke line3 = new BasicStroke(1);
					g2.setStroke(line3);
					g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
					g2.setColor(new Color(0, 0, 150));

					k = (stats.h < stats.w) ? stats.h / r : stats.w / r;
					
					if (x > algus_punkt_x &&  x < laius + algus_punkt_x) 
						g2.drawLine(x, algus_punkt_y, x, stats.h + algus_punkt_y); // y telje joon
					if(x + 10 > algus_punkt_x &&  x + 15 < laius + algus_punkt_x) 
						g2.drawString("Y", x + 10, 20 + algus_punkt_y);
					if (y > algus_punkt_y &&  y < korgus + algus_punkt_y) 
						g2.drawLine(algus_punkt_x, y, stats.w + algus_punkt_x, y); // x telje joon
					if (y - 10 > algus_punkt_y &&  y - 15 < korgus + algus_punkt_y) 
						g2.drawString("X", stats.w - 20 + algus_punkt_x, y - 10);
					if (x - 4 > algus_punkt_x &&  x < laius + algus_punkt_x && y - 50 * k > algus_punkt_y &&  y - 50 * k < korgus + algus_punkt_y) 
						g2.fillOval(x - 4, (int)(y - 50 * k), 8, 8); // yleval julla
					if(x - 4 > algus_punkt_x &&  x < laius + algus_punkt_x && y + 50 * k > algus_punkt_y &&  y + 55 * k < korgus + algus_punkt_y) 
						g2.fillOval(x - 4, (int)(y +  50 * k), 8, 8); // all julla
					if(x - 50 * k > algus_punkt_x &&  x - 45 * k < laius + algus_punkt_x && y - 4 > algus_punkt_y &&  y < korgus + algus_punkt_y) 
						g2.fillOval((int)(x - 50 * k), y - 4, 8, 8); // vasak julla
					if(x + 50 * k > algus_punkt_x &&  x + 55 * k < laius + algus_punkt_x && y - 4 > algus_punkt_y &&  y < korgus + algus_punkt_y) 
						g2.fillOval((int)(x + 50 * k), y - 4, 8, 8); // parem julla
					if(x - 24 > algus_punkt_x &&  x < laius + algus_punkt_x && y - 59 * k > algus_punkt_y &&  y - 52 * k < korgus + algus_punkt_y) 
						g2.drawString("50", x - 24, (int)(y - 52 * k)); // yleval
					if(x + 7 > algus_punkt_x &&  x + 20 < laius + algus_punkt_x && y + 50 * k > algus_punkt_y &&  y + 60 * k < korgus + algus_punkt_y) 
						g2.drawString("-50", x + 7, (int)(y + 57 * k)); // all
					if(x - 57 * k > algus_punkt_x &&  x - 52 * k < laius + algus_punkt_x && y - 19 > algus_punkt_y &&  y < korgus + algus_punkt_y) 
						g2.drawString("-50", (int)(x - 57 * k), y - 9); // vasak
					if(x + 52 * k > algus_punkt_x &&  x + 60 * k < laius + algus_punkt_x && y - 20 > algus_punkt_y &&  y + 15 < korgus + algus_punkt_y) 
						g2.drawString("50", (int)(x + 52 * k), y + 20); // parem
					if (stats.naitakoord) {
						if(stats.X_koord > algus_punkt_x &&  stats.X_koord < laius + algus_punkt_x && stats.Y_koord > algus_punkt_y &&  stats.Y_koord < korgus + algus_punkt_y) {
							g2.drawString("x=" + nf.format((stats.X_koord - x) / k), stats.X_koord, stats.Y_koord + 30);
							g2.drawString("y=" + nf.format(-(stats.Y_koord - y) / k), stats.X_koord, stats.Y_koord + 42); 
						}
					}
				
					if (naita_vektorite_liitmist) {
						// System.out.println("Liitmine laks käima");
						for (vektori_nr = 0; vektori_nr < liituvate_vektorite_kogu.size() ; vektori_nr++) { // vektorid ArrayList -ist
							// System.out.println("Vektor nr=" + vektori_nr + "Vektorikogu.size=" + vektorikogu.size());
							Vektor vektor = liituvate_vektorite_kogu.get(vektori_nr);

							if (vektori_nr == parajasti_liidetav_vektor) {
								Vektor vektor_mis_on_aluseks = vektorikogu.get(vektori_nr); // selle vektori võtame kogu aeg originaalses positsioonis
							
								if (tehte_liik==2) {
									// lahutamine - suunad vaja muuta
									vektor_mis_on_aluseks =vektorikogu_suunad_lahutamiseks.get(vektori_nr);
								}
							
								// nihutame siis seda vektorit mida on vaja liita sinna eelmise vektori noole otsa
								// System.out.println("Vektor ENNE x1:" + vektor.getX_alg() + " x2:" + vektor.getX_lypp() + " y1:"+vektor.getY_alg()+ " y2:" + vektor.getX_lypp());
								Vektor eelmine = liituvate_vektorite_kogu.get(vektori_nr - 1);	
								// System.out.println("Eelmine x2:" + eelmine.getX_lypp() + " y2:" + eelmine.getY_lypp());
									
								double temp_x_algus = arvuta_koordinaat(vektor_mis_on_aluseks.getX_alg(), eelmine.getX_lypp());
								double temp_y_algus = arvuta_koordinaat(vektor_mis_on_aluseks.getY_alg(), eelmine.getY_lypp());
								double vahe_x = vektor_mis_on_aluseks.getX_alg() - temp_x_algus;
								double vahe_y = vektor_mis_on_aluseks.getY_alg() - temp_y_algus;
								double temp_x_lopp = vektor_mis_on_aluseks.getX_lypp() - vahe_x;
								double temp_y_lopp = vektor_mis_on_aluseks.getY_lypp() - vahe_y;

								/*
								double temp_x_lopp = arvuta_koordinaat( vektor_mis_on_aluseks.getX_lypp(), (vektor_mis_on_aluseks.getX_lypp() - vahe_x));
								double temp_y_lopp = arvuta_koordinaat( vektor_mis_on_aluseks.getY_lypp(), (vektor_mis_on_aluseks.getY_lypp() - vahe_y));
								 */

								vektor.setX_alg(temp_x_algus);
								vektor.setY_alg(temp_y_algus);
								vektor.setX_lypp(temp_x_lopp);
								vektor.setY_lypp(temp_y_lopp);
							
								// System.out.println("Vektor PÄRAST x1:" + vektor.getX_alg() + " x2:" + vektor.getX_lypp() + " y1:"+vektor.getY_alg()+ " y2:" + vektor.getX_lypp());
								// g2.drawLine(temp_x_algus, temp_y_algus, temp_x_lopp, temp_y_lopp);
							
								if ((int) vektor.getX_alg()== (int) eelmine.getX_lypp() && (int) vektor.getY_alg()== (int) eelmine.getY_lypp()) {
									if (vektori_nr==(liituvate_vektorite_kogu.size()-1)) {
										// Viimane vektor edukalt liidetud 
										// System.out.println("Viimane vektor edukalt liidetud");
										// siin tõmbame esimese vektori ja viimase vahele joone
										taimer.stop();
									
										Vektor esimene_vektor = liituvate_vektorite_kogu.get(0);
										vektorite_liitmise_tulemus = new Vektor (esimene_vektor.getX_alg(), esimene_vektor.getY_alg(), vektor.getX_lypp(),vektor.getY_lypp());	
									
										for (int j = 0; j < liituvate_vektorite_kogu.size() ;j++) {
											Vektor nimedoonor = liituvate_vektorite_kogu.get(j);
											if (j==0) {
												vektorite_liitmise_tulemus.nimi = 	vektorite_liitmise_tulemus.nimi + nimedoonor.nimi;
											} else {
												if (tehte_liik==1) {
													vektorite_liitmise_tulemus.nimi = 	vektorite_liitmise_tulemus.nimi + "+" + nimedoonor.nimi;
												} else {
													vektorite_liitmise_tulemus.nimi = 	vektorite_liitmise_tulemus.nimi + "-" + nimedoonor.nimi;
												}
											
											}
									
										}
										if (pane_liidetud_tulemus_vilkuma) {
											pane_liidetud_tulemus_vilkuma=false;
											liidetud_vektori_timer.start();
										}
									} else {
										// System.out.println("Liidame järgmise vektori, vektori_nr:" + + vektori_nr + " liituvate_vektorite_kogu.size():" + liituvate_vektorite_kogu.size());
										parajasti_liidetav_vektor++;
										time=1;
									}
								
								} // end if (vektor.getX_alg()== eelmine.getX_lypp() && vektor.getY_alg()== eelmine.getY_lypp()) {
							} // end if (vektori_nr == parajasti_liidetav_vektor) {
						
							g2.setColor(tagasta_varv(vektori_nr));
							joonesta_vektor(g2, vektor, stats, laius, korgus, algus_punkt_x, algus_punkt_y);
						
							if (naita_lypp_liidetavat) {
								if (tehte_liik==1) {
									g2.setColor(Color.BLUE);
								}
							
								if (tehte_liik==2) {
									g2.setColor(Color.RED);
								}
								joonesta_vektor(g2, vektorite_liitmise_tulemus, stats, laius, korgus, algus_punkt_x, algus_punkt_y);
							}
						} // end for vektorid ArrayList -ist
					
					} else {
						for (vektori_nr = 0; vektori_nr < vektorikogu.size() ; vektori_nr++) { // vektorid ArrayList -ist
							// System.out.println("Vektor nr=" + vektori_nr + "Vektorikogu.size=" + vektorikogu.size());
							Vektor vektor = vektorikogu.get(vektori_nr);
							g2.setColor(tagasta_varv(vektori_nr));
							joonesta_vektor(g2, vektor, stats, laius, korgus, algus_punkt_x, algus_punkt_y);
							// joonesta_kaar(g2, x2, y2, x1, y1);
						} // end for
						g2.setColor(tagasta_varv(vektori_nr));
					
						if (stats.joonistame_uut_vektorit) {
							double pikkus = Math.sqrt(Math.pow(stats.x2-stats.x1, 2) + Math.pow(stats.y2-stats.y1, 2)) / k; // vektori pikkus 
							g2.drawString("||" + nf.format(pikkus) +"||", stats.x2, stats.y2-15);
							g2.drawLine(stats.x1, stats.y1, stats.x2, stats.y2);
							joonesta_nool(g2, stats.x2, stats.y2,stats.x1, stats.y1, stats);
							g2.setStroke(line3);
							joonesta_kaar(g2, stats.x2, stats.y2, stats.x1, stats.y1);
						} // end if (joonistame_uut_vektorit) {
					
					} // end else if (naita_vektorite_liitmist) {
				} // end if (koord)
				
				/* 
				if (time > 100) {
					g2.setColor(Color.BLUE);
					g2.drawLine(130, 130, temp_x_lopp, temp_y_lopp);
				}
				*/
			} // end display_vektorid

			private void display_ylesanne (Graphics g) {
				zuum_valja_nupp.setVisible(true);
				zuum_sisse_nupp.setVisible(true);
				suurenda.setVisible(false);
				v2henda.setVisible(false);
				int strHeight; //height of the string.
				Graphics2D g2 = (Graphics2D) g;
				g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
				Color display;
				String display_string;
				Ylesanne ylesanne = new Ylesanne(0);
				ylesanne = fyysika_ylesanded.otsi_ylesanne_nr(fyysika_ylesanded.getActive_ylesanne());
				ArrayList <String> stringid  = new ArrayList <String> ();
				Font bigBoldFont = new Font("Arial Unicode MS", Font.BOLD, zoomSize/2);
				g.setFont(bigBoldFont);
				FontMetrics fm = g.getFontMetrics(bigBoldFont);
				strHeight = fm.getAscent();
				display = Color.black;
				g.setColor(display);
				display_string = ylesanne.getTekst();
				int reacounter = 0;
				stringid= poolita_string(g, display_string, bigBoldFont);
				for (int i = 0; i < stringid.size();i++) {
					g.drawString(stringid.get(i), 10, strHeight +  strHeight * reacounter++);
				}
				for (int i = 1; i < ylesanne.getActive_step_nr() + 1; i++) {
					Ylesande_step current_step = ylesanne.stepid.get(i-1);
					display_string = current_step.getVihje();
					display = new Color(0, 99, 0); // DarkSeaGreen;
					g.setColor(display);
					
					stringid= poolita_string(g, display_string, bigBoldFont);
					for (int z = 0; z < stringid.size();z++) {
						g.drawString(stringid.get(z), 30, strHeight +  strHeight * reacounter++);
					}
					if (current_step.isNaita_lahendust()) {
						display = new Color(65, 105, 225);
						g.setColor(display);
						display_string = current_step.getStepi_lahendus();	
						stringid= poolita_string(g, display_string, bigBoldFont);
						for (int z = 0; z < stringid.size();z++) {
							g.drawString(stringid.get(z), 30, strHeight +  strHeight * reacounter++);
						}
					}
				}
			}
			public void joonesta_vektor(Graphics2D g2, Vektor vektor,Animatsiooni_statsid stats, int laius, int korgus, int algus_punkt_x, int algus_punkt_y) {
				g2.setStroke(new BasicStroke(2));
				double x1 = vektor.getX_alg(), y1 = vektor.getY_alg(), x2 = vektor.getX_lypp(), y2 = vektor.getY_lypp();
				double x1_pixel = stats.w/2 + stats.X_nihe + x1 * k + algus_punkt_x;
				double y1_pixel = stats.h/2 + stats.Y_nihe - y1 * k + algus_punkt_y;
				double x2_pixel = stats.w/2+ stats.X_nihe + x2 * k + algus_punkt_x;
				double y2_pixel = stats.h/2 + stats.Y_nihe - y2 * k + algus_punkt_y;
				double slope = (y2_pixel - y1_pixel) / (x2_pixel - x1_pixel);  // vektori tõus
				double x_top = (algus_punkt_y - y1_pixel) / slope + x1_pixel; // l6ikekoht ylemine serv
				double x_bottom = (algus_punkt_y + korgus - y1_pixel) / slope + x1_pixel;
				double y_left = slope * (algus_punkt_x - x1_pixel) + y1_pixel; //l6ikekoht vasak serv
				double y_right = slope * (algus_punkt_x + laius - x1_pixel) + y1_pixel;
				g2.fillOval((int) x_top, algus_punkt_y, 5, 5); // debug
				g2.fillOval((int) x_bottom, algus_punkt_y + korgus, 5, 5); // DEBUG
				g2.fillOval(algus_punkt_x, (int) y_left, 5, 5);
				g2.fillOval(algus_punkt_x + laius, (int) y_right, 5, 5);
				
				if (x1_pixel > algus_punkt_x && x2_pixel > algus_punkt_x && x1_pixel < algus_punkt_x + laius && x2_pixel < algus_punkt_x + laius
						&& y1_pixel > algus_punkt_y && y2_pixel > algus_punkt_y && y1_pixel < algus_punkt_y + korgus && y2_pixel < algus_punkt_y + korgus) {
					// m6lemad vektori punktid on sees 
					g2.drawLine((int) x1_pixel, (int) y1_pixel, (int) x2_pixel, (int) y2_pixel);
				}
				else {
					if ((x1_pixel <= algus_punkt_x && y1_pixel <= algus_punkt_y) || (x1_pixel <= algus_punkt_x && y1_pixel >= algus_punkt_y)
							|| (x1_pixel >= algus_punkt_x && y1_pixel >= algus_punkt_y+korgus) || (x1_pixel >= algus_punkt_x+laius && y1_pixel >= algus_punkt_y+korgus) 
							|| (x1_pixel >= algus_punkt_x+laius && y1_pixel <= algus_punkt_y+korgus) || (x1_pixel <= algus_punkt_x+laius && y1_pixel <= algus_punkt_y)) {
						// vektori algus punkt on v2ljas
						if ( ! ((x2_pixel <= algus_punkt_x && y2_pixel <= algus_punkt_y) || (x2_pixel <= algus_punkt_x && y2_pixel >= algus_punkt_y)
								|| (x2_pixel >= algus_punkt_x && y2_pixel >= algus_punkt_y+korgus) || (x2_pixel >= algus_punkt_x+laius && y2_pixel >= algus_punkt_y+korgus) 
								|| (x2_pixel >= algus_punkt_x+laius && y2_pixel <= algus_punkt_y+korgus) || (x2_pixel <= algus_punkt_x+laius && y2_pixel <= algus_punkt_y))) {
							// vektori algus on v2ljas ja l6pp on sees
							x2 = x2_pixel;
							y2 = y2_pixel;
							if(y1_pixel <= algus_punkt_y && x_top >= algus_punkt_x && x_top <= algus_punkt_x + laius) {
								x1 = x_top;
								y1 = algus_punkt_y;
							}
							if(y1_pixel >= algus_punkt_y + korgus && x_bottom >= algus_punkt_x && x_bottom <= algus_punkt_x + laius) {
								x1 = x_bottom;
								y1 = algus_punkt_y + korgus;
							}
							if(x1_pixel <= algus_punkt_x && y_left >= algus_punkt_y  && y_left <= algus_punkt_y+korgus) {
								x1 = algus_punkt_x;
								y1 = y_left;
							}
							if(x1_pixel >= algus_punkt_x+laius && y_right >= algus_punkt_y && y_right <= algus_punkt_y + korgus) {
								x1 = algus_punkt_x + laius;
								y1 = y_right;
							}
						}
						if ((x2_pixel <= algus_punkt_x && y2_pixel <= algus_punkt_y) || (x2_pixel <= algus_punkt_x && y2_pixel >= algus_punkt_y)
								|| (x2_pixel >= algus_punkt_x && y2_pixel >= algus_punkt_y+korgus) || (x2_pixel >= algus_punkt_x+laius && y2_pixel >= algus_punkt_y+korgus) 
								|| (x2_pixel >= algus_punkt_x+laius && y2_pixel <= algus_punkt_y+korgus) || (x2_pixel <= algus_punkt_x+laius && y2_pixel <= algus_punkt_y)) {
							// m6lemad vektori punktid on v2ljas
							if((x_top < algus_punkt_x && x_bottom < algus_punkt_x && y_left < algus_punkt_y && y_right < algus_punkt_y) 
									|| (x_top < algus_punkt_x && x_bottom < algus_punkt_x && y_left > algus_punkt_y+korgus && y_right > algus_punkt_y+korgus) 
									|| (x_top > algus_punkt_x+laius && x_bottom > algus_punkt_x+laius && y_left > algus_punkt_y+korgus && y_right > algus_punkt_y+korgus)
									|| (x_top > algus_punkt_x+laius && x_bottom > algus_punkt_x+laius && y_left < algus_punkt_y && y_right < algus_punkt_y)) { 
								// EI JOONESTA midagi kuna ka 4 punkti on v2ljas (x_top, y_left jne)
								return;
								
							} else { // m6lemad vektori punktid on v2ljas aga osa vektorist ikkagi n2ha
								// ei joonesta 
								if(x2_pixel <= algus_punkt_x && x1_pixel <= algus_punkt_x || x1_pixel >= algus_punkt_x+laius && x2_pixel >= algus_punkt_x+laius) return;
								if(y1_pixel <= algus_punkt_y && y2_pixel <= algus_punkt_y || y1_pixel >= algus_punkt_y+korgus && y2_pixel >= algus_punkt_y+korgus) return;
								// joonestame 
								if(x_top > algus_punkt_x && x_top < algus_punkt_x+laius && y_left > algus_punkt_y && y_left < algus_punkt_y+korgus) {
									x1 = algus_punkt_x; // ylemine vasak nurk
									y1 = y_left;
									x2 = x_top;
									y2 = algus_punkt_y;
								}
								if(y_left > algus_punkt_y && y_left < algus_punkt_y+korgus && x_bottom > algus_punkt_x && x_bottom < algus_punkt_x+laius) {
									x1 = algus_punkt_x; // alumine vasak nurk
									y1 = y_left;
									x2 = x_bottom;
									y2 = algus_punkt_y + korgus;
								}
								if(y_right > algus_punkt_y && y_right < algus_punkt_y+korgus && x_bottom > algus_punkt_x && x_bottom < algus_punkt_x+laius) {
									x1 = algus_punkt_x + laius; // alumine parem nurk
									y1 = y_right;
									x2 = x_bottom;
									y2 = algus_punkt_y + korgus;
								}
								if(y_right > algus_punkt_y && y_right < algus_punkt_y+korgus && x_top > algus_punkt_x && x_top < algus_punkt_x+laius) {
									x1 = algus_punkt_x + laius; // ylemine parem nurk
									y1 = y_right;
									x2 = x_top;
									y2 = algus_punkt_y;
								}
								if(((x1_pixel <= algus_punkt_x && x2_pixel >= algus_punkt_x+laius) || (x2_pixel <= algus_punkt_x && x1_pixel >= algus_punkt_x+laius)) 
										&& y_left > algus_punkt_y && y_left < algus_punkt_y+korgus && y_right > algus_punkt_y && y_right < algus_punkt_y+korgus) {
									x1 = algus_punkt_x; // vasakult servast paremale
									y1 = y_left;
									x2 = algus_punkt_x + laius;
									y2 = y_right;
								}
								if(((y1_pixel <= algus_punkt_y && y2_pixel >= algus_punkt_y+korgus) || (y2_pixel <= algus_punkt_y && y1_pixel >= algus_punkt_y+korgus)) 
										&& x_top > algus_punkt_x && x_top < algus_punkt_x+laius && x_bottom > algus_punkt_x && x_bottom < algus_punkt_x+laius) {
									x1 = x_top; // ylevalt servast alla
									y1 = algus_punkt_y;
									x2 = x_bottom;
									y2 = algus_punkt_y + korgus;
								}
							} // end else osa vektorist n2ha
						} // end if m6lemad vektori punktid v2ljas
						
					} else { // vektori algus punkt on sees
						if ((x2_pixel <= algus_punkt_x && y2_pixel <= algus_punkt_y) || (x2_pixel <= algus_punkt_x && y2_pixel >= algus_punkt_y)
							|| (x2_pixel >= algus_punkt_x && y2_pixel >= algus_punkt_y+korgus) || (x2_pixel >= algus_punkt_x+laius && y2_pixel >= algus_punkt_y+korgus) 
							|| (x2_pixel >= algus_punkt_x+laius && y2_pixel <= algus_punkt_y+korgus) || (x2_pixel <= algus_punkt_x+laius && y2_pixel <= algus_punkt_y)) {
							// vektori l6pp punkt on v2ljas
							x1 = x1_pixel;
							y1 = y1_pixel;
							if(y2_pixel <= algus_punkt_y && x_top >= algus_punkt_x && x_top <= algus_punkt_x + laius) {
								x2 = x_top;
								y2 = algus_punkt_y;
							}
							if(y2_pixel >= algus_punkt_y + korgus && x_bottom >= algus_punkt_x && x_bottom <= algus_punkt_x + laius) {
								x2 = x_bottom;
								y2 = algus_punkt_y+korgus;
							}
							if(x2_pixel <= algus_punkt_x && y_left >= algus_punkt_y  && y_left <= algus_punkt_y+korgus) {
								x2 = algus_punkt_x;
								y2 = y_left;
							}
							if(x2_pixel >= algus_punkt_x + laius && y_right >= algus_punkt_y && y_right <= algus_punkt_y + korgus) {
								x2 = algus_punkt_x + laius;
								y2 = y_right;
							}
						}
					} // end else
					
					g2.drawLine((int) x1, (int) y1, (int) x2, (int) y2); // SIIN JOONESTUB POOLIK VEKTOR
					
				} // end else if m6lemad punktid n2ha
				
				if (x2_pixel > algus_punkt_x && x2_pixel < algus_punkt_x + laius && y2_pixel > algus_punkt_y && y2_pixel < algus_punkt_y + korgus) {
					joonesta_nool(g2, (int)x2_pixel, (int)y2_pixel, (int)x1_pixel, (int)y1_pixel, stats);
				}
				int x = (int) (stats.w/2 + stats.X_nihe + algus_punkt_x + vektor.keskmine_x_pos() * k);
				int y = (int) (stats.h/2 + stats.Y_nihe + algus_punkt_y - vektor.keskmine_y_pos() * k);
				if (x > algus_punkt_x && x < algus_punkt_x + laius && y > algus_punkt_y && y < algus_punkt_y + korgus) {
					g2.setColor(Color.black);
					g2.drawString(vektor.nimi, x, y);
				}
				/* g2.setStroke(new BasicStroke(1));
				double vektori_y_telg_positsioon = vektori_projektsioon_x_telg (g2,  y1);
				double vektori_x_telg_positsioon = vektori_projektsioon_y_telg (g2,  x1);
				punktiir_joon(g2, x2_pixel, y1_pixel, x2_pixel, y2_pixel); // punktiir x teljele
				punktiir_joon(g2, x1_pixel, y2_pixel, x2_pixel, y2_pixel); // punktiir y teljele
				g2.setStroke(new BasicStroke(2));
				g2.drawLine((int) x1_pixel,(int) vektori_y_telg_positsioon,(int) x2_pixel, (int) vektori_y_telg_positsioon); // projektsioon x teljele
				g2.drawLine((int) vektori_x_telg_positsioon, (int) y1_pixel,(int) vektori_x_telg_positsioon,(int) y2_pixel); // projektsioon x teljele
				double keskmine_x_pos = (x1_pixel+x2_pixel)/2; double keskmine_y_pos = (y1_pixel+y2_pixel)/2;
				g2.drawString(vektor.nimi + "x", (int)keskmine_x_pos, (int)y1_pixel);  g2.setColor(Color.RED);
				g2.drawString(vektor.nimi + "y", (int)x1_pixel, (int)keskmine_y_pos); */
			}
			
			public void joonesta_nool (Graphics2D g2, int nooleots_x, int nooleots_y, int vektor_algus_x, int vektor_algus_y,Animatsiooni_statsid stats) {
				double dx = nooleots_x - vektor_algus_x, dy = nooleots_y - vektor_algus_y;
				double phi = Math.PI / 9;  // phi on noole ja vektori vaheline nurk
				double theta = Math.atan2(dy, dx), x, y, rho = theta + phi;
				for (int j = 0; j < 2; j++) {
					x = nooleots_x - stats.noolepikkus * Math.cos(rho);
					y = nooleots_y - stats.noolepikkus * Math.sin(rho);
					g2.draw(new Line2D.Double(nooleots_x, nooleots_y, x, y));
					rho = theta - phi;
				}
			}
			
			public void joonesta_kaar (Graphics2D g2, int x2, int y2, int x1, int y1) {
				double dx = x2 - x1, dy = y2 - y1, theta = - Math.atan2(dy, dx), theta_d;
				theta_d = Math.toDegrees(theta);
				if(theta_d < 0) theta_d = theta_d + 360;
				g2.setColor(new Color(255, 0, 0));
				g2.drawArc(x1 - 15, y1 - 15, 30, 30, 0, (int) theta_d);
				g2.drawString("" + nf.format(theta_d), x1 + 15, y1 - 15);
			}
			
			public double vektori_projektsioon_x_telg (Graphics2D g2, double vektor_algus_y,Animatsiooni_statsid stats) {
				g2.setColor(new Color(0, 120, 0));
				g2.drawLine((int)0 -10000 , (int) (stats.h/2 + stats.Y_nihe - vektor_algus_y * k),(int) 10000, (int) (stats.h/2 + stats.Y_nihe -  vektor_algus_y*k)); // x telje joon
				return (stats.h/2 + stats.Y_nihe - vektor_algus_y * k);
			}
			
			public void punktiir_joon(Graphics2D g2, double algus_x, double algus_y, double lypp_x, double lypp_y) {
				g2.setColor(Color.DARK_GRAY);
				 Stroke stroke = new BasicStroke(2, BasicStroke.CAP_BUTT, 
				            BasicStroke.JOIN_BEVEL, 10, new float[] {5,5}, 0);
				 g2.setStroke(stroke);
				 g2.drawLine((int)algus_x,(int)algus_y,(int)lypp_x,(int)lypp_y);
			}
			
			public double vektori_projektsioon_y_telg (Graphics2D g2, double vektor_algus_x,Animatsiooni_statsid stats) {
				g2.setColor(new Color(120, 0, 0));
				// g2.drawLine((int) vektor_algus_x + X_nihe, 0 -10000 + Y_nihe, (int) vektor_algus_x + X_nihe, h + 10000 + Y_nihe); // y telje joon
				g2.drawLine((int) (stats.w/2 + stats.X_nihe + vektor_algus_x * k), (int) (0 -10000), (int) (stats.w/2+ stats.X_nihe +  vektor_algus_x*k), 10000);
				return (stats.w/2 + stats.X_nihe + vektor_algus_x * k);
			}
			
			public double arvuta_koordinaat (double algus, double lypp) {
				double teepikkus = lypp -  algus;
				teepikkus = teepikkus / 100 * time;
				return (algus + teepikkus);
			}
			
			public ArrayList <String> poolita_string(Graphics g, String display_string, Font bigBoldFont) {
				int strWidth;
				FontMetrics fm = g.getFontMetrics(bigBoldFont);
				strWidth = fm.stringWidth(display_string); 
				ArrayList <String> stringid  = new ArrayList <String> ();	
				if (strWidth > scrollPane.getWidth()) { 				
					   // on vaja poolitada
					while (fm.stringWidth(display_string) > (scrollPane.getWidth() - scrollPane.getWidth()/10)) {
						strWidth = fm.stringWidth(display_string);
						int char_arv = display_string.length();
						int yhe_tahe_suurus=strWidth / char_arv;
						int fromIndex = (int) (scrollPane.getWidth() - scrollPane.getWidth() / 4.2) / yhe_tahe_suurus; 
						int poolita_kohal = display_string.indexOf(" ", fromIndex);
						if (poolita_kohal < 0) {
							break;
						}
						stringid.add(display_string.substring(0, poolita_kohal));
						display_string = display_string.substring(poolita_kohal, char_arv);
					}
				}
				stringid.add(display_string);
				return stringid;
			}

			@Override
			public void mousePressed(MouseEvent e) {
				Animatsiooni_statsid current_stats = animatsioonide_kogum.get(0);	
				if (!e.isMetaDown()  && display_mode == 0) {
					naita_vektorite_liitmist= false; //TODO
					current_stats.joonistame_uut_vektorit = true;
				}
				current_stats.x1 = e.getX();
				current_stats.x2 = e.getX();
				current_stats.y1 = e.getY();
				current_stats.y2 = e.getY();
				repaint();
			}

			@Override
			public void mouseDragged(MouseEvent e) {
				Animatsiooni_statsid current_stats = animatsioonide_kogum.get(0);
				if (e.isMetaDown()) {
					current_stats.joonistame_uut_vektorit = false;
					current_stats.X_nihe = current_stats.X_nihe + current_stats.X_koord - current_stats.X_last;
					current_stats.Y_nihe = current_stats.Y_nihe + current_stats.Y_koord - current_stats.Y_last;
					current_stats.X_last = current_stats.X_koord;
					current_stats.Y_last = current_stats.Y_koord;
					repaint();
				}
				else {
					current_stats.x2 = e.getX();
					current_stats.y2 = e.getY();
					if (current_stats.joonistame_uut_vektorit) {
						repaint();
					}
				}
				current_stats.X_koord = e.getX();
				current_stats.Y_koord = e.getY();
			}

			@Override
			public void mouseReleased(MouseEvent e) {
				Animatsiooni_statsid current_stats = animatsioonide_kogum.get(0);
				if (!e.isMetaDown() && display_mode == 0) {
				// kas eksisteerib 0 pikkusega vektoreid? igaks juhuks ei lase neid joonistada
					if (current_stats.x1==current_stats.x2 && current_stats.y1==current_stats.y2) {
						// System.out.println("Null pikkusega vektor");
					} else {
						int algus_punkt_x = getWidth()/4, algus_punkt_y = getHeight()/4;
						double x1 = (current_stats.x1 - current_stats.X_nihe - current_stats.w/2 - algus_punkt_x) / k;
						double y1 = -(current_stats.y1 - current_stats.Y_nihe - current_stats.h/2 - algus_punkt_y) / k;
						double x2 = (current_stats.x2 - current_stats.X_nihe - current_stats.w/2 - algus_punkt_x) / k;
						double y2 = -(current_stats.y2 - current_stats.Y_nihe - current_stats.h/2 - algus_punkt_y) / k;
						uus_vektor = new Vektor (x1, y1, x2, y2);
						vektorikogu.add_vektor(uus_vektor);
						current_stats.joonistame_uut_vektorit = false;
					}
					repaint();
					kustutamise_menyy();
					
				} // end if (!e.isMetaDown()) {
			}
			@Override
			public void mouseMoved(MouseEvent e) {
				Animatsiooni_statsid current_stats = animatsioonide_kogum.get(0);
				
				current_stats.X_koord = e.getX();
				current_stats.Y_koord = e.getY();
				current_stats.X_last = current_stats.X_koord;
				current_stats.Y_last = current_stats.Y_koord;
				repaint();
			}
			@Override
			public void mouseClicked(MouseEvent e) {
				
				
			}
			@Override
			public void mouseEntered(MouseEvent e) {
				Animatsiooni_statsid current_stats = animatsioonide_kogum.get(0);
				current_stats.naitakoord = true;
			}
			@Override
			public void mouseExited(MouseEvent e) { 
				Animatsiooni_statsid current_stats = animatsioonide_kogum.get(0);
				current_stats.naitakoord = false;
				repaint();
			}

			@Override
			public void mouseWheelMoved(MouseWheelEvent e) {
				
				 int notches = e.getWheelRotation();
			       if (notches < 0) {
			           
			           r = r * 0.8; 
			          // System.out.println( "Mouse wheel moved UP " + -notches + " notch(es)" + " new r:" + r);
			       } else {
			    	   r = r * 1.2;    
			    	  // System.out.println("Mouse wheel moved DOWN "    + notches + " notch(es)"+ " new r:" + r);
			    	        
			       }
			
				repaint();
			}

		} // end class KeskPaneel

		public Color tagasta_varv(int varv_nr) {
			Color display = Color.GREEN;

			if (varv_nr == 0)
				display = new Color(205, 92, 92); // IndianRed
			if (varv_nr == 1)
				display = new Color(255, 140, 0); // DarkOrange
			if (varv_nr == 2)
				display = new Color(189, 183, 107); // DarkKhaki
			if (varv_nr == 3)
				display = new Color(0, 255, 0); // Green
			if (varv_nr == 4)
				display = new Color(255, 105, 180); // HotPink
			if (varv_nr == 5)
				display = new Color(255, 20, 147); // DeepPink
			if (varv_nr == 6)
				display = new Color(255, 127, 80); // Coral
			if (varv_nr == 7)
				display = new Color(218, 165, 32); // Goldenrod
			if (varv_nr == 8)
				display = new Color(255, 69, 0); // OrangeRed
			if (varv_nr == 9)
				display = new Color(250, 128, 114); // Salmon
			if (varv_nr == 10)
				display = new Color(255, 215, 0); // Gold
			if (varv_nr == 11)
				display = new Color(255, 0, 0); // Red
			if (varv_nr == 12)
				display = new Color(240, 230, 140); // Khaki
			if (varv_nr == 13)
				display = Color.CYAN; // Cyan
			if (varv_nr == 14)
				display = new Color(238, 130, 238); // Violet
			if (varv_nr == 15)
				display = new Color(153, 102, 204); // Amethyst
			if (varv_nr == 16)
				display = new Color(106, 90, 205); // SlateBlue
			if (varv_nr == 17)
				display = new Color(152, 251, 152); // PaleGreen
			if (varv_nr == 18)
				display = new Color(154, 205, 50); // YellowGreen
			if (varv_nr == 19)
				display = new Color(143, 188, 143); // DarkSeaGreen
			if (varv_nr == 20)
				display = new Color(192, 192, 192); // Silver
			if (varv_nr == 21)
				display = new Color(210, 105, 30); // Chocolate
			if (varv_nr == 22)
				display = new Color(160, 82, 45); // Sienna
			if (varv_nr == 23)
				display = new Color(65, 105, 225); // RoyalBlue
			if (varv_nr == 24)
				display = new Color(127, 255, 212); // Aquamarine

			return display;
		}

		private class VektorKogum {
			public int id = 0;
			ArrayList<Vektor> vektorid = new ArrayList<Vektor>();
			private String alphabet = "ABCDEFGHIJKLMNOPRSTUWXYZ";

			public void add_vektor(Vektor vektor) {
				
				if (vektor.nimi.equals("")) {
					
						if (id >=  alphabet.length()) {
							vektor.nimi=""+id;
						} else {
							vektor.nimi=""+alphabet.charAt(id);
						}
				}
				id ++;
				this.vektorid.add(vektor);
				
			}

			public int size() {
				return this.vektorid.size();
			}

			public Vektor get(int i) {
				return vektorid.get(i);
			}
			
			public VektorKogum make_copy_of_yourself(int tehte_liik) {
				VektorKogum uusVektorKogum = new VektorKogum();
				for (int i = 0; i < vektorid.size();i++) {
					Vektor uus = new Vektor();
					if (i == 0) {
						// System.out.println("Tehe esimene vektor, hardcore liitmine");
						uus.copy_Vektor(vektorid.get(i),1);
					} else {
						// System.out.println("Tehe muu vektor"+ i + "tehte_liik:" + tehte_liik);
						uus.copy_Vektor(vektorid.get(i),tehte_liik);
					}

					uusVektorKogum.add_vektor(uus);
				}
				
				return uusVektorKogum;
			}

		}

		private class Vektor {
			private double x_alg, y_alg, x_lypp, y_lypp;
			public String nimi="";

			Vektor() {
				set_cordinates(0, 0, 0, 0);
				// construktor
			}

			Vektor(double x_alg, double y_alg, double x_lypp, double y_lypp) {
				set_cordinates(x_alg, x_lypp, y_alg, y_lypp);
				// constructor II
				
				// vektorikogu.add_vektor(new Vektor (0, 0, 38.7, 61.4));
			}

			public void copy_Vektor(Vektor copytav_vektor, int tehte_liik) {
				
				if (tehte_liik==1) {
					this.setX_alg(copytav_vektor.getX_alg());
					this.setX_lypp(copytav_vektor.getX_lypp());
					this.setY_alg(copytav_vektor.getY_alg());
					this.setY_lypp(copytav_vektor.getY_lypp());
					this.nimi=copytav_vektor.nimi;
				}
				if (tehte_liik==2) {
					this.setX_alg(copytav_vektor.getX_lypp());
					this.setX_lypp(copytav_vektor.getX_alg());
					this.setY_alg(copytav_vektor.getY_lypp());
					this.setY_lypp(copytav_vektor.getY_alg());
					this.nimi=copytav_vektor.nimi;
					
				}
				
			}

			public void set_cordinates(double x_alg, double x_lypp, double y_alg, double y_lypp) {
				this.setX_alg(x_alg);
				this.setX_lypp(x_lypp);
				this.setY_alg(y_alg);
				this.setY_lypp(y_lypp);
			}
			
			public double keskmine_x_pos() {
				return (int)((this.getX_alg()+this.getX_lypp())/2);
			}
			
			public double keskmine_y_pos() {
				return (int)((this.getY_alg()+this.getY_lypp())/2);
			}
			
			public void setX_alg(double x_alg) {
				this.x_alg = x_alg;
			}

			public double getX_alg() {
				return x_alg;
			}

			public void setY_alg(double y_alg) {
				this.y_alg = y_alg;
			}

			public double getY_alg() {
				return y_alg;
			}

			public void setX_lypp(double x_lypp) {
				this.x_lypp = x_lypp;
			}

			public double getX_lypp() {
				return x_lypp;
			}

			public void setY_lypp(double y_lypp) {
				this.y_lypp = y_lypp;
			}

			public double getY_lypp() {
				return y_lypp;
			}
		}

		public JMenuBar getMenuBar() {
			menubar = new JMenuBar();
			esimene_Menu = new JMenu("Vektorid");
			teine_Menu = new JMenu("Kustuta");
			kolmas_Menu = new JMenu("Ülesanne");
			menubar.add(esimene_Menu);
			menubar.add(teine_Menu);
			menubar.add(kolmas_Menu);
			suurenda = new JButton("Suurenda");
			suurenda.addActionListener(this);
			v2henda = new JButton("Vähenda");
			v2henda.addActionListener(this);
			menubar.add(suurenda);
			menubar.add(v2henda);
			zuum_sisse_nupp = new JButton("Zoom +");
			zuum_sisse_nupp.addActionListener(this);
			menubar.add(zuum_sisse_nupp);
			zuum_valja_nupp = new JButton("Zoom -");
			zuum_valja_nupp.addActionListener(this);
			menubar.add(zuum_valja_nupp);
			eelmine_samm = new JButton("Eelmine samm");
			eelmine_samm.addActionListener(this);
			jargmine_samm = new JButton("Jargmine samm");
			jargmine_samm.addActionListener(this);
			vaata_lahendust = new JButton("Vaata lahendust");
			vaata_lahendust.addActionListener(this);
			vaata_anim = new JButton("Vaata joonist");
			vaata_anim.addActionListener(this);
			menubar.add(eelmine_samm);
			menubar.add(jargmine_samm);
			menubar.add(vaata_lahendust);
			menubar.add(vaata_anim);

			item = new JMenuItem("Vektorite paneel");
			item.addActionListener(this);
			esimene_Menu.add(item);
			esimene_Menu.addSeparator();
			item = new JMenuItem("Liida vektorid");
			item.addActionListener(this);
			esimene_Menu.add(item);
			item = new JMenuItem("Lahuta vektorid");
			item.addActionListener(this);
			esimene_Menu.add(item);
			
			item = new JMenuItem("Kustuta kõik");
			item.addActionListener(this);
			teine_Menu.add(item);
			teine_Menu.addSeparator();

			item = new JMenuItem("Ülesanne 3");
			item.addActionListener(this);
			kolmas_Menu.add(item);

			return menubar;
		}

		public void kustutamise_menyy () {
			teine_Menu.removeAll();
			item = new JMenuItem("Kustuta kõik");
			item.addActionListener(mycanvas);
			teine_Menu.add(item);
			teine_Menu.addSeparator();
			kustutaMenuItem.clear();
			for (int i = 0; i < vektorikogu.size() ; i++) {
				kustutaMenuItem.add(new JMenuItem("Vektor nr " + (i+1)));
				kustutaMenuItem.get(i).setSelected(true);
				kustutaMenuItem.get(i).addActionListener(mycanvas);
				teine_Menu.add(kustutaMenuItem.get(i));
			}
		}
		
		public void zoom_in() {
			zoomSize = zoomSize + (int) Math.max(zoomSize * 0.5, 1);
			zuum_valja_nupp.setEnabled(true);
			if (zoomSize > 300) {
				zuum_sisse_nupp.setEnabled(false);
			}
		}

		public void zoom_out() {
			zoomSize = (int) (zoomSize * 0.7);
			zuum_sisse_nupp.setEnabled(true);
			if (zoomSize < 6) {
				zuum_valja_nupp.setEnabled(false);
			}
		}

		private void kontrolli_ylesannete_nuppude_staatust() {
			Ylesanne ylesanne = fyysika_ylesanded.otsi_ylesanne_nr(fyysika_ylesanded.getActive_ylesanne()); 

			eelmine_samm.setEnabled(true);
			jargmine_samm.setEnabled(true);
			vaata_lahendust.setEnabled(true);

			if (ylesanne.getActive_step_nr()==0) {
				eelmine_samm.setEnabled(false);
				vaata_lahendust.setEnabled(false);	
			}
			if (ylesanne.getActive_step_nr()==ylesanne.stepid.size()) {
				jargmine_samm.setEnabled(false);
			}

			if (ylesanne.getActive_step_nr() > 0) {
				Ylesande_step current_step = ylesanne.stepid.get(ylesanne.getActive_step_nr() - 1);
				if (current_step.isNaita_lahendust()) {
					vaata_lahendust.setEnabled(false);	
				}
			}
		}

		private void eelmine_samm() {
			Ylesanne ylesanne = fyysika_ylesanded.otsi_ylesanne_nr(fyysika_ylesanded.getActive_ylesanne()); 
			if (ylesanne.getActive_step_nr() > 0) ylesanne.setActive_step_nr(ylesanne.getActive_step_nr()-1);
			kontrolli_ylesannete_nuppude_staatust();
		}
		
		private void jargmine_samm() {
			Ylesanne ylesanne = fyysika_ylesanded.otsi_ylesanne_nr(fyysika_ylesanded.getActive_ylesanne()); 
			if (ylesanne.getActive_step_nr() < ylesanne.stepid.size()) 
				ylesanne.setActive_step_nr(ylesanne.getActive_step_nr() + 1);
			kontrolli_ylesannete_nuppude_staatust();
		}

		private void vaata_lahendust() {
			Ylesanne ylesanne = fyysika_ylesanded.otsi_ylesanne_nr(fyysika_ylesanded.getActive_ylesanne()); 
			if (ylesanne.getActive_step_nr() > 0) {
				Ylesande_step current_step = ylesanne.stepid.get(ylesanne.getActive_step_nr() - 1);
				current_step.setNaita_lahendust(true);
			}
			kontrolli_ylesannete_nuppude_staatust();
		}

		public void liit_lahut() {
			naita_vektorite_liitmist= false;
			repaint();
			display_mode = 0;
			time_liidetav_vektor=1;
			yl_nupud_nahtamatuks();
			liituvate_vektorite_kogu = vektorikogu.make_copy_of_yourself(tehte_liik);
			if (tehte_liik==2) {
				vektorikogu_suunad_lahutamiseks = vektorikogu.make_copy_of_yourself(tehte_liik);
			}
			
			
			parajasti_liidetav_vektor=1;
			naita_vektorite_liitmist= true;
			pane_liidetud_tulemus_vilkuma=true;
			naita_lypp_liidetavat = false;
			time=1;
			taimer.start();
			
		}
		@Override
		public void actionPerformed(ActionEvent e) {
			String command = e.getActionCommand();
			if (command.equals("Liida vektorid")) {
				
				tehte_liik = 1;
				liit_lahut();
			}
			
			if (command.equals("Lahuta vektorid")) {
				tehte_liik = 2;
				liit_lahut();
			}
			
			
			if (command.equals("Ülesanne 3")) {
				yl_nupud_nahtavaks();
				fyysika_ylesanded.setActive_ylesanne(0);
				display_mode=1;
			}
			if (command.equals("Vektorite paneel")) {
				display_mode = 0;
				yl_nupud_nahtamatuks();
			}
			if (command.equals("Kustuta kõik")) {
				naita_vektorite_liitmist= false;
				vektorikogu.vektorid.clear();
				vektorikogu.id = 0;
				kustutamise_menyy();
			}
			if (command.contains("Vektor nr")) {
				command = command.substring(10, command.length());
				naita_vektorite_liitmist= false;
				vektorikogu.vektorid.remove(Integer.valueOf(command) - 1); 
				if (vektorikogu.vektorid.size() == 0) 
					vektorikogu.id = 0;
				kustutamise_menyy();
			}
			if (command.equals("Zoom +")) {
				zoom_in();
			}
			if (command.equals("Zoom -")) {
				zoom_out();
			}
			if (command.equals("Eelmine samm")) {
				eelmine_samm();
			}
			if (command.equals("Jargmine samm")) {
				jargmine_samm();
			}
			if (command.equals("Vaata lahendust")) {
				vaata_lahendust();
			}
			if (command.equals("Vaata joonist")) {
				display_mode = 2;
			}
			if (command.equals(suurenda.getText())) {
				r = r * 0.8;
			}
			if (command.equals(v2henda.getText())) {
				r = r * 1.2;
			}
			/* if (command.equals(kiirenda_anim.getText())) {
				aeg = aeg + 1;
				if (aeg > 8) {
					aeg = 8;
				}
			}
			if (command.equals(aeglusta_anim.getText())) {
				aeg = aeg - 1;
				if (aeg == 0) {
					aeg = 1;
				}
			} */
			
			super.repaint();
		}
	}

	public void init() {
		setLayout(new BorderLayout());
		resize(900, 600);
		add(mycanvas, BorderLayout.CENTER);
	}

}
